using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Estructuras.Estructura;

namespace Estructuras.Comunes
{
    public class ObtenerElementos
    {
        /// <summary>
        /// Nombre del fichero de entrada de datos.
        /// </summary>
        public string nombreFicheroEntrada = string.Empty;

        /// <summary>
        /// Nombre del fichero de salida de datos.
        /// </summary>
        public string nombreFicheroSalida = string.Empty;

        /// <summary>
        /// Constructor.
        /// </summary>
        public ObtenerElementos()
        {
        }

        /// <summary>
        /// Obtiene un flujo de datos a partir del fichero de entrada indicado.
        /// </summary>
        /// <param name="nombreFicheroEntrada">Fichero de entrada de datos</param>
        /// <returns>Flujo de datos de entrada</returns>
        public TextReader ObtenerOrigenDatos(string nombreFicheroEntrada)
        {
            this.nombreFicheroEntrada = nombreFicheroEntrada;
            if (string.Empty.Equals(this.nombreFicheroEntrada))
                throw new Excepcion(Constantes.ERROR_VALOR_ENTRADA_DATOS_NO_INDICADO, Constantes.CODIGO_ERROR_VALOR_ENTRADA_DATOS_NO_INDICADO);
            try
            {
                return Comunes.ObtenerEntrada(this.nombreFicheroEntrada);
            }
            catch (Excepcion ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new Excepcion(Constantes.ERROR_OBTENER_ENTRADA_DATOS + ex.Message, Constantes.CODIGO_ERROR_OBTENER_ENTRADA_DATOS);
            }
        }

        /// <summary>
        /// Obtiene un flujo de datos a partir del fichero de salida indicado.
        /// </summary>
        /// <param name="nombreFicheroSalida">Fichero de salida de datos</param>
        /// <returns>Flujo de datos de salida</returns>
        public TextWriter ObtenerDestinoDatos(string nombreFicheroSalida)
        {
            this.nombreFicheroSalida = nombreFicheroSalida;
            if (string.Empty.Equals(this.nombreFicheroSalida))
                throw new Excepcion(Constantes.ERROR_VALOR_SALIDA_DATOS_NO_INDICADO, Constantes.CODIGO_ERROR_VALOR_SALIDA_DATOS_NO_INDICADO);
            try
            {
                return Comunes.ObtenerSalida(this.nombreFicheroSalida);
            }
            catch (Excepcion ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new Excepcion(Constantes.ERROR_OBTENER_SALIDA_DATOS + ex.Message, Constantes.CODIGO_ERROR_OBTENER_SALIDA_DATOS);
            }
        }

        /// <summary>
        /// Obtiene la estructura del fichero de estructuras indicado.
        /// </summary>
        /// <param name="nombreEstructura">Fichero de estructuras</param>
        /// <returns>Estructura del fichero</returns>
        public Estructura.Estructura ObtenerEstructura(string nombreEstructura)
        {
            if (string.Empty.Equals(nombreEstructura))
                throw new Excepcion(Constantes.ERROR_VALOR_ESTRUCTURA_DATOS_NO_INDICADO, Constantes.CODIGO_ERROR_VALOR_ESTRUCTURA_DATOS_NO_INDICADO);
            try
            {
                return new Estructura.Estructura(nombreEstructura);
            }
            catch (Excepcion ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new Excepcion(Constantes.ERROR_OBTENER_ESTRUCTURA_DATOS + ex.Message, Constantes.CODIGO_ERROR_OBTENER_ESTRUCTURA_DATOS);
            }
        }

        /// <summary>
        /// Cierra el flujo de entrada de datos.
        /// </summary>
        /// <param name="entrada">Flujo de entrada de datos</param>
        public void CerrarOrigenDatos(TextReader entrada)
        {
            try
            {
                Comunes.CerrarEntrada(entrada, nombreFicheroEntrada);
            }
            catch (Excepcion ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new Excepcion(Constantes.ERROR_CERRAR_ENTRADA_DATOS + ex.Message, Constantes.CODIGO_ERROR_CERRAR_ENTRADA_DATOS);
            }
        }

        /// <summary>
        /// Cierra el flujo de datos de salida.
        /// </summary>
        /// <param name="salida">Flujo de salida de datos</param>
        public void CerrarDestinoDatos(TextWriter salida)
        {
            try
            {
                Comunes.CerrarSalida(salida, nombreFicheroSalida);
            }
            catch (Excepcion ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new Excepcion(Constantes.ERROR_CERRAR_SALIDA_DATOS + ex.Message, Constantes.CODIGO_ERROR_CERRAR_SALIDA_DATOS);
            }
        }
    }
}
